Everything about Type Polymorphism totally explained
In computer science, polymorphism is a programming language feature that allows values of different data types to be handled using a uniform interface. The concept of parametric polymorphism applies to both data types and functions. A function that can evaluate to or be applied to values of different types is known as a polymorphic function. A data type that can appear to be of a generalized type (for example, a list with elements of arbitrary type) is designated polymorphic data type like the generalized type from which such specializations are made.
There are two fundamentally different kinds of polymorphism, originally informally described by Christopher Strachey in 1967. If the range of actual types that can be used is finite and the combinations must be specified individually prior to use, it's called Ad-hoc polymorphism. If all code is written without mention of any specific type and thus can be used transparently with any number of new types, it's called parametric polymorphism. John C. Reynolds (and later Jean-Yves Girard) formally developed this notion of polymorphism as an extension to the lambda calculus (called the polymorphic lambda calculus, or System F).
In object-oriented programming, ad-hoc polymorphism is generally supported through object inheritance, for example, objects of different types may be treated uniformly as members of a common superclass. Ad-hoc polymorphism is also supported in many languages using function and method overloading.
Parametric polymorphism is widely supported in statically typedfunctional programming languages. In the object-oriented programming community, programming using parametric polymorphism is often called generic programming.
Polymorphism in strongly-typed languages
Parametric polymorphism
Parametric polymorphism is a way to make a language more expressive, while still maintaining full static type-safety. Using parametric polymorphism, a function or a data type can be written generically so that it can handle values identically without depending on their type.
For example, a function append that joins two lists can be constructed so that it doesn't care about the type of elements: it can append lists of integers, lists of real numbers, lists of strings, and so on. Let the type variable a denote the type of elements in the lists. Then append can be typed [a] × [a] → [a], where [a] denotes a list of elements of type a. We say that the type of append is parameterized by a for all values of a. (Note that since there's only one type variable, the function can't be applied to just any pair of lists: the pair, as well as the result list, must consist of the same type of elements.) For each place where append is applied, a value is decided for a.
Parametric polymorphism was first introduced to programming languages in ML in 1976. Today it exists in Standard ML, OCaml, Haskell, Visual Prolog and others. Java and C# have both recently introduced "generics" for parametric polymorphism.
The most general form of polymorphism is "higher-rank impredicative polymorphism". Two popular restrictions of this form are restricted rank polymorphism (for example, rank-1 or prenex polymorphism) and predicative polymorphism. Together, these restrictions give "predicative prenex polymorphism", which is essentially the form of polymorphism found in ML and early versions of Haskell.
Rank restrictions
Rank-1 (prenex) polymorphism
In a prenex polymorphic system, type variables may not be instantiated with polymorphic types. This is very similar to what is called "ML-style" or "Let-polymorphism" (technically ML's Let-polymorphism has a few other syntactic restrictions).
This restriction makes the distinction between polymorphic and non-polymorphic types very important; thus in predicative systems polymorphic types are sometimes referred to as type schemas to distinguish them from ordinary (monomorphic) types, which are sometimes called monotypes. A consequence is that all types can be written in a form which places all quantifiers at the outermost (prenex) position.
For example, consider the append function described above, which has type [a] × [a] → [a]; in order to apply this function to a pair of lists, a type must be substituted for the variable a in the type of the function such that the type of the arguments matches up with the resulting function type. In an impredicative system, the type being substituted may be any type whatsoever, including a type that's itself polymorphic; thus append can be applied to pairs of lists with elements of any type -- even to lists of polymorphic functions such as append itself.
Polymorphism in the language ML and its close relatives is predicative. This is because predicativity, together with other restrictions, makes the type system simple enough that type inference is possible. In languages where explicit type annotations are necessary when applying a polymorphic function, the predicativity restriction is less important; thus these languages are generally impredicative. Haskell manages to achieve type inference without predicativity but with a few complications.
Rank-k polymorphism
For some fixed value k, rank-k polymorphism is a system in which a quantifier may not appear to the left of more than k arrows (when the type is drawn as a tree) chose the term ad-hoc polymorphism to refer to polymorphic functions which can be applied to arguments of different types, but which behave differently depending on the type of the argument to which they're applied (also known as function overloading). The term "ad hoc" in this context isn't intended to be pejorative; it refers simply to the fact that this type of polymorphism isn't a fundamental feature of the type system.
Ad-hoc polymorphism is a dispatch mechanism: code moving through one named function is dispatched to various other functions without having to specify the exact function being called. Overloading allows multiple functions taking different types to be defined with the same name; the compiler or interpreter automatically calls the right one. This way, functions appending lists of integers, lists of strings, lists of real numbers, and so on could be written, and all be called append—and the right append function would be called based on the type of lists being appended. This differs from parametric polymorphism, in which the function would need to be written generically, to work with any kind of list. Using overloading, it's possible to have a function perform two completely different things based on the type of input passed to it; this isn't possible with parametric polymorphism. Another way to look at overloading is that a routine is uniquely identified not by its name, but by the combination of its name and the number, order and types of its parameters.
This type of polymorphism is common in object-oriented programming languages, many of which allow operators to be overloaded in a manner similar to functions (see operator overloading). Some languages which are not dynamically typed and lack ad-hoc polymorphism (including type classes) have longer function names such as print_int, print_string, etc. This can be seen as advantage (more descriptive) or a disadvantage (more long-winded) depending on one's point of view.
An advantage that's sometimes gained from overloading is the appearance of specialization, for example, a function with the same name can be implemented in multiple different ways, each optimized for the particular data types that it operates on. This can provide a convenient interface for code that needs to be specialized to multiple situations for performance reasons.
Since overloading is done at compile time, it isn't a substitute for late binding as found in subtyping polymorphism.
Example
This example aims to illustrate three different kinds of polymorphism described in this article. Though overloading an originally arithmetic operator to do a wide variety of things in this way may not be the most clear-cut example, it allows some subtle points to be made. In practice, the different types of polymorphism are not generally mixed up as much as they're here.
Imagine an operator + that may be used in the following ways:
In the last case, string concatenation must be invoked, unless this too is handled as list concatenation (for example, Haskell).
Thus, the name + actually refers to three or four completely different functions. This is an example of overloading.
Override polymorphism
Override polymorphism is an override of existing code. Subclasses of existing classes are given a "replacement method" for methods in the superclass. Superclass objects may also use the replacement methods when dealing with objects of the subtype. The replacement method that a subclass provides has exactly the same signature as the original method in the superclass (return type, number and type of parameters etc.)
Java API Example: For Java, every object is a subdivsion of Object. Java's Object class has a method called toString, which returns a string representation of the object (usually a reference value which is useful for debugging reasons .
Object is a superclass of BigDecimal. Thus when implementing BigDecimal, the author can override the method toString, so toString returns more meaningful information: a string representation of the value that's stored in this particular BigDecimal object. One therefore says BigDecimal.toString overrides Object.toString.
Example
Object obj = new Object;
System.out.println(obj.toString);
BigDecimal decimal = new java.math.BigDecimal("0.0");
System.out.println(decimal.toString);
/*
BigDecimal objAsDec = new Object; // illegal
System.out.println(objAsDec.toString);
/
Object decAsObj = new java.math.BigDecimal("1.0");
System.out.println(decAsObj.toString);
the output is:
java.lang.Object@86c347
0.0
1.0
As you can see, in the first two cases the toString method that matches the type or class of the object is called. For obj this is Object's toString method, and for decimal this is BigDecimal's toString method.
objAsDec would give a compile time error. If the compiler were to actually allow the creation of objAsDec, and it were passed later to a method that calls a BigDecimal class method, there would be a problem: objAsDec is actually an Object, not a BigDecimal.
decAsObj isn't illegal, and is a more interesting case. The runtime type of the decAsObj reference is Object, even though the object it points to is a BigDecimal. However, when toString is called upon it, BigDecimal's toString method is the one to be called.
Imagine if decAsObj had been put in an Object[] array, then passed to a method which loops over the array calling the toString on each reference in the array. When it came to decAsObj, the method that would actually be called wouldn't be the same method as a plain Object like obj. This proves that in Java, it can't be decided which particular method will actually be called at compile time. This is called dynamic binding.
Parametric polymorphism
Finally, the reason why we can concatenate both lists of integers, lists of booleans, and lists of characters, is that the function for list concatenation was written without any regard to the type of elements stored in the lists. This is an example of parametric polymorphism. If you wanted to, you could make up a thousand different new types of lists, and the generic list concatenation function would happily and without requiring any augmentation accept instances of them all.
It can be argued, however, that this polymorphism isn't really a property of the function per se; that if the function is polymorphic, it's due to the fact that the list data type is polymorphic. This is true—to an extent, at least—but it's important to note that the function could just as well have been defined to take as a second argument an element to append to the list, instead of another list to concatenate to the first. If this were the case, the function would indisputably be parametrically polymorphic, because it could then not know anything about its second argument, except that the type of the element should match the type of the elements of the list.
Do you know how hard it is to get a link from a large encyclopaedia? Well we're different and will prove it. To get a link from us just add the following HTML to your site on a relevant page:
Then simply click through this link from your web page. Our crawlers will verify your link, extract the title of your web page and instantly add a link back to it. If you like you can remove the words Totally Explained and embed the link in article text.
As long as your link remains in place, we'll keep our link to you right here. Please play fair - our crawlers are watching. Your site must be closely related to this one's topic. Any kind of spamming, dubious practises or removing the link will result in your link from us being dropped and, potentially, your whole site being banned.
